/**
 * Created by Administrator on 2022/7/31.
 */
public class Demo {
    public static void main(String[] args) {
        //arithmeticOperator();//算术运算符
        //compoundOperator();//增量运算符（复合运算符）
        //incrementOperator();//自增运算符
        //relationalOperator();//条件运算符
        //logicalOperator();//逻辑运算符
        //bitOperator();//位运算符
        //shiftOperators();//移位运算符
        //conditionalOperator();//条件运算符
    }
    public static void arithmeticOperator() {
        //算术运算符
        int a = 3;
        int b = 2;
        System.out.println(a + b);
        System.out.println(a - b);
        System.out.println(a * b);
        System.out.println(a / b);//整型 / 整型 = 整型
        System.out.println(a % b);

        //如果想要得到数学算术中一样的小数值
        double c = a * 1.0 / b;//方法一
        double d = (double)a / b;//方法二
        System.out.println(c);
        System.out.println(d);

        /*做除法和取模时，右操作数不能为0
        int e = 6;
        int f = 0;
        System.out.println(e / f);
        System.out.println(e % f);*/

        //% 不仅可以对整形取模，也可以对double类型取模，但是没有意义，一般都是对整形取模的
        double g = 7.5;
        double h = 6.5;
        System.out.println(g % h);

        //两侧操作数类型不一致时，向类型大的提升
        System.out.println(1 + 6.1);
    }

    public static void compoundOperator() {
        //增量运算符 +=  -=  *=  %=
        int a = 10;
        a -= 3;//相当于 a = a - 3
        System.out.println(a);
        a += 2;//相当于 a = a + 3
        System.out.println(a);
        a *= 3;//相当于 a = a * 3
        System.out.println(a);
        a /= 3;//相当于 a = a / 3
        System.out.println(a);

    }

    public static void incrementOperator() {
        //自增/自减运算符 ++ --
        //++是给变量的值+1，--是给变量的值-1
        int a = 6;
        int b = a++;//先把 a 的值赋值给 b ，然后 a 再 ++ ，b = 6,a = 7
        System.out.println(b);
        int c = ++b;//b 先 ++ ，然后赋值给 c ，c = 7 ,b = 7
        System.out.println(c);
        int d = c--;//先把 c 的值赋值给 d ，然后 c 再 -- ，d = 7 ，c = 6
        System.out.println(d);
        int e = --d;//d 先 -- ，然后赋值给 e ，e = 6， d = 6
        System.out.println(e);
        //只有变量才能使用自增/自减运算符，常量不能使用，因为常量不允许被修改
    }

    public static void relationalOperator(){
        //关系运算符: == != < > <= >= ，其计算结果是 true 或者 false
        System.out.println(6 == 7);
        System.out.println(6 != 7);
        System.out.println(6 < 7);
        System.out.println(6 > 7);
        System.out.println(6 <= 7);
        System.out.println(6 >= 7);
    }

    public static void logicalOperator(){
        //逻辑运算符: && || ! ，运算结果都是 boolean类型
        //注：两边表达式的结果都是Boolean类型结果

        int a = 6;
        int b = 7;
        //&&-->逻辑与:两边表达式的结果都为真结果才为真。
        System.out.println(a > 2 && b < 9);//当左侧表达式值为 true，则判断右边表达式值是否为 true，若是 最后结果就是 true
        System.out.println(a > 7 && b > 1);//当左侧表达式值为 false, 则表达式结果一定是 false, 无需计算右侧表达式

        //||-->逻辑或：两边表达式的结果只要有一个为真则为真
        System.out.println(a > 3 || b > 9);//当左侧表达式值为 true, 则表达式结果一定是 true, 无需计算右侧表达式
        System.out.println(a > 9 || b < 9);//当左侧表达式值为 false，则判断右边表达式值是否为 true，若是 则为true，否则为false

        //！-->逻辑非：真变假，假变真
        System.out.println(!(a==b));//表达式值为 false，结果则为 true
        System.out.println(!(a==6));//表达式值为true，结果则为 false
    }

    public static void bitOperator(){
       // 位运算符: & | ~ ^
       /*位操作表示 按二进制位运算. 计算机中都是使用二进制来表示数据的(01构成的序列),
       按位运算就是在按照二进制位的每一位依次进行计算.*/

       // & -->按位与：如果两个二进制位都是 1, 则结果为 1, 否则结果为 0(全一得一)
        int a = 10;
        int b = 20;
        System.out.println(a & b);
        //a-->10:00000000 00000000 00000000 00001010
       //&
        //b-->20:00000000 00000000 00000000 00010100
        //-------------------------------------------
        //       00000000 00000000 00000000 00000000-->0


        // | -->按位或：如果两个二进制位都是 0, 则结果为 0, 否则结果为 1（见一得一）
        System.out.println(a | b);
        //a-->10:00000000 00000000 00000000 00001010
        //|
        //b-->20:00000000 00000000 00000000 00010100
        //-------------------------------------------
        //       00000000 00000000 00000000 00011110-->30


        // ~ -->按位取反：如果该位为 0 则转为 1, 如果该位为 1 则转为 0
        System.out.println(~a);
        //a-->10:00000000 00000000 00000000 00001010
        //    ~
        //-------------------------------------------
        //       11111111 11111111 11111111 11110101 -->补码
        //       10000000 00000000 00000000 00001010 -->反码
        //       10000000 00000000 00000000 00001011 -->原码


        // ^ -->按位异或：: 如果两个数字的二进制位相同, 则结果为 0, 相异则结果为 1.（相同为0，不同为1）
        System.out.println(a ^ b);
        //a-->10:00000000 00000000 00000000 00001010
        //^
        //b-->20:00000000 00000000 00000000 00010100
        //-------------------------------------------
        //       00000000 00000000 00000000 00011110-->30
    }


    public static void shiftOperators(){
        //移位运算符: << >> >>>,都是按照二进制比特位来运算的
        int a = 10;
        // << 左移： 最左侧位不要了, 最右侧补 0
        System.out.println(a << 1);
        //  a-->10:00000000 00000000 00000000 00001010
        //  << 1
        //-------------------------------------------
        //         00000000 00000000 00000000 00010100-->20

        // >> 右移：最右侧位不要了, 最左侧补符号位(正数补0, 负数补1)
        System.out.println(a >> 1);
        //  a-->10:00000000 00000000 00000000 00001010
        //  >> 1
        //-------------------------------------------
        //         00000000 00000000 00000000 00000101-->5

        // >>> 无符号左移：最右侧位不要了, 最左侧补 0
        int b = -10;
        System.out.println(b >>> 1);
        //如果是负数，则需要转为补码然后存储在计算机内进行运算
        //  b-->-10:10000000 00000000 00000000 00001010 --> 原码
        //          11111111 11111111 11111111 11110101 --> 反码
        //          11111111 11111111 11111111 11110100 --> 补码
        //   >>> 1
        //------------------------------------------------------
        //          01111111 11111111 11111111 11111010 --> 2147483642
    }

    public static void conditionalOperator(){
        //条件运算符：表达式1 ? 表达式2 : 表达式3
        //当表达式1为true，则返回表达式2的值，否则返回表达式三的值
        int a = 10;
        int b = 20;
        System.out.println(a > b ? a : b);
        System.out.println(a < b ? a : b);

    }


}
